import org.junit.Test;
import org.junit.Test;


import java.lang.reflect.Array;
import java.util.Arrays;

/**
 * 程序只有一个入口：main方法，  程序入口
 * 理解：类中只有一个主方法
 *
 * 类中多个类似主方法：单元测试 Junit1.4 【外置jar包】
 *                 jar 别人写好的类直接使用
 * 单元测试：专门测试功能模块
 * 单元测试步骤
 * 1.编写注解 @Test
 * 2.编写方法  修饰符 返回值 方法名（）{}
 */
//public class 基础语法 {
    /**
     * float 单精度 取小数点后六位有效数
     * 写法：float 标识符=字面量F/f;
     */
    //@Test
    //public void basic() {
// float pi = 3.1415926535F;
    // System.out.println(pi);//3.1415927
    //int a = 128 + 256;
    // byte b = (byte) a;
    //System.out.println(b);

    // String name = "yu";
    //int age = 18;
    // System.out.println(name + age);
    // }

    /**
     * 数组 Array 引用类型    对象，通过new创建
     * 数组相当于一堆相同数据集合
     * 单元测试：testArray 创建数组以及初始化
     */
  //  @Test
    //public void testArray() {
        //创建arr空数组，长度4
        // int[] arr = new int[4];//动态初始化：指定空间，并且按照空间分元素
        // int[] arr1 = {1, 2, 3};//静态初始化：直接给定值
        //   int arr2[] = new int[4];//动态初始化：指定空间，并且按照空间分元素
        // int[] arr3 = new int[]{1, 2, 3};//动态初始化：指定空间，并且按照空间分元素
        //从arr1静态初始化数组获取2元素  数组名[下标:默认从0开始]
        // System.out.println(arr1[1]);//输出2元素值
        //从arr1静态初始化数组获取长度
        // System.out.println(arr1.length);//输出3
        //从arr1获取下标为4的值 输出？ 数组下标越界异常
        // System.out.println(arr1[4]);//ArrayIndexOutOfBoundsException
        //空间长度没有超出范围，数据类型：基础数据类型
            /*
            int    默认值  0
            float默认值  0
            char默认值  0
            boolean默认值  false
             */
        // int[] arr4 = new int[4];
        // System.out.println(arr4[1]);
        // float[] arr5 = new float[4];
        //System.out.println(arr5[1]);
        //char[] arr6 = new char[4];
        // System.out.println(arr6[1]);
        //boolean[] arr7 = new boolean[4];
        //System.out.println(arr7[1]);
        // }

        /**
         * 数据遍历【三种迭代方式】
         * 1.普通for jdk1.5之前使用
         * 2.增强forjdk1.5之后使用 推荐
         * 3.工具类 推荐
         */
        // @Test
        // public void testIterate() {
        // int[] arr = {1, 2, 3, 4};//静态数据
        //  for (int i = 0; i < arr.length; i++) {//获取数组的下标
        // System.out.println(arr[i]);{
        //        }
        ////遍历数据类型 引用名：数组名
        //for(int i:arr){//直接打印元素值
        // System.out.println(i);
        //  }
        //        //工具类 toString方法 打印所有数组元素
        // System.out.println(Arrays.toString(arr));
        // }

        // /*
        //    数组扩容
        //    java数组对象大小是固定的，数组对象不可以扩容
        //    使用数据扩充方式进行变通
        //       Arrays.copyOf()方法创建数组副本。
        //     */
        // @Test
        //public void testCopy() {
        //  char[] arr = {'唐', '山'};  //定义数组，长度固定：2个
        //         使用Arrays提供copyOf方法创建当前数组的副本
        //char[]temp= Arrays.copyOf(arr,newLength:4);
        //副本 复制给 不可改变数组
        //char[] tarr=temp;
//System.out.println(tarr);
//tarr[2]='工';
//tarr[3]='业';
//System.out.println(tarr);
/**
 * 拓展:数组输出，根据数据类型不同，输出效果不同【看】
 * 数组语法：
 *        数据类型【】 数组名=new数据类型【】；
 *        数据类型：基础数据类型+引用类型
 *        创建数据根据数据类型：明确是什么类型
 */

    //}

  //  @Test
   // public void testLook() {
        //字符数组---输出方式
     //   char[] china = {'中', '国'};
      //  System.out.println(china);  //输出中国
        //JavaOOP面向对象知识点：
        //数组输出方法提供重载功能，字符数组，优化为字符串
        //常规数组输出效果  Arrays工具类 toString方法：打印数组
       // System.out.println(Arrays.toString(china));

        //数值数值
       // int[] i = {1, 2};
        //System.out.println(i);//[ 数组 I int类型   @   地址值759ebb3d
        //查看数组实际效果
        //System.out.println(Arrays.toString(i));
   // }

    /**
     * 数组经典案例：
     * int[] arr={3,6,4,1}
     * 数组元素排序：升序  降序
     * 面试题：上述数组按照升序方式排序
     * 解题思路三种方案：选择排序 、冒泡排序√、插入排序
     * 冒泡排序：双层for循环使用，比较相邻的元素，将元素数值小的值放到前面
     */
   // @Test
    //public void bubbleSort() {
      //  int[] arr = {3, 6, 4, 1};//静态数组
        //   for   外层循环【轮】+for内层循环【次】
        //考虑;每一轮需要比较几次
        //for (int i = 0; i < arr.length - 1; i++) {//外层控制   3轮   拿到结果
          //  for (int j = 0; j < arr.length - 1 - i; j++) {//内层控制 3次递减
                //交换：第一个值>第二个值  成立   交换
              //  if (arr[j] > arr[j + 1]) {//第一个值：元素数arr【j】    第二值：元素数arr【j+1】
                    //交换第三方数组变量    交换数组名temp
                   // int temp = arr[j];//1.第一个值交给第三方数组变量
                   // arr[j] = arr[j + 1];//2.第二个值交给了第一个值
                   // arr[j + 1] = temp;  //3.第三方变量交给第二个值
             //   }

           // }
       // }
       // System.out.println(Arrays.toString(arr));


        //for(int i=0;i<arr.length-1;i++){//外层for：控制比较轮
        // for(int j=0;j<arr.length-1-i;j++){ //内层for:两两比较
        //交换   升序：从小到大
        //  if(arr[j]>arr[j+1]){
        ///    int temp=arr[j];
        //    arr[j]=arr[j+1];
        //   arr[j+1]=temp;
        // }

        //}
        // }
        // System.out.println(Arrays.toString(arr));

      //  @Test
       // public void static() {
        //    int[] arr = {3, 6, 4, 1};
            //工具类：提供sort（）排序方法
           // Arrays.sort(arr);  //默认升序
           // System.out.println(Arrays.toString(arr));
      //  }

    //}
//}